package util;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
import sun.misc.BASE64Encoder;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.Hashtable;

/**
 * @author cxt
 * @date 2020/8/27
 * 生成二维码图片文件
 * <p>
 * 导入jar包
 * <dependency>
 *      <groupId>com.google.zxing</groupId>
 *      <artifactId>javase</artifactId>
 *      <version>3.3.3</version>
 * </dependency>
 */
public class MatrixToImageUtil {

    public static void main(String[] args) throws IOException, WriterException {
        // 使用流的方式获取二维码
        String s = steamPrintln("http://www.baidu.com", "E:\\log.png", 200, 200);
        // 把生成的编码打印出来
        System.out.println(s);

        // 将生成的二维码保存在本地磁盘
        localFile("http://www.baidu.com", "E:\\log1.png", 200, 200, "E:\\er.png");
    }

    /**
     * 输出二维码方式：本地文件的方式
     *
     * @param content  二维码图片展示的内容
     * @param logPath  log图片的路径
     * @param width    二维码的宽
     * @param height   二维码的高
     * @param filePath 保存二维码的地址
     */
    public static void localFile(String content, String logPath, int width, int height, String filePath) throws IOException, WriterException {
        BufferedImage bufImg = makeMatrixImg(content, logPath, width, height);
        OutputStream os = new FileOutputStream(filePath);
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(os);
        encoder.encode(bufImg);
    }

    /**
     * 输出二维码的方式：stream流的方式
     *
     * @param content 二维码图片展示的内容
     * @param logPath log图片的路径
     * @param width   二维码的宽
     * @param height  二维码的高
     */
    public static String steamPrintln(String content, String logPath, int width, int height) throws IOException, WriterException {
        BufferedImage bufferedImage = makeMatrixImg(content, logPath, width, height);
        try {
            // ByteArrayOutputStream或ByteArrayInputStream是内存读写流，
            // 不同于指向硬盘的流，它内部是使用字节数组读内存的，这个字节数组是它的成员变量，
            // 当这个数组不再使用变成垃圾的时候，Java的垃圾回收机制会将它回收。所以不需要关流!
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ImageIO.write(bufferedImage, "png", out);
            // 将流转成数组
            byte[] bytes = out.toByteArray();
            BASE64Encoder encoder = new BASE64Encoder();
            return "data:image/png;base64," + encoder.encodeBuffer(bytes).trim();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 生成二维码的方法
     * 存在log图片时候输入含有log图片的二维码，log图片不存在时候输出不含log图片的二维码
     *
     * @param content 二维码图片展示的内容
     * @param logPath log图片的路径
     * @param width   二维码的宽
     * @param height  二维码的高
     * @throws WriterException
     * @throws IOException
     */
    public static BufferedImage makeMatrixImg(String content, String logPath, int width, int height) throws WriterException, IOException {
        // 将内容写入矩阵
        Hashtable<EncodeHintType, String> matrix = new Hashtable<EncodeHintType, String>();
        // 设置矩阵所使用的编码格式
        matrix.put(EncodeHintType.CHARACTER_SET, "utf-8");
        // 初始化矩阵，并将矩阵图形化
        BufferedImage matrixImage = toBufferredImage(new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, width, height, matrix));
        // 读取log图片
        File file = new File(logPath);
        if (file.exists()) {
            BufferedImage logImage = ImageIO.read(file);
            // log图片过大，使得二维码无法扫描
            // 判断log图片是否过大，log图片的大小不大于二维码大小的六分之一
            int oneSixthW = width / 6;
            int oneSixthH = height / 6;
            if (logImage.getWidth() > oneSixthW || logImage.getHeight() > oneSixthH) {
                // 重新生成一个合适的log图片
                BufferedImage newImage = new BufferedImage(oneSixthW, oneSixthH, BufferedImage.TYPE_INT_RGB);
                Graphics2D graphics = newImage.createGraphics();
                graphics.drawImage(logImage, 0, 0, oneSixthW, oneSixthH, null);
                graphics.dispose();
                return drawNewImage(matrixImage, newImage);
            } else {
                return drawNewImage(matrixImage, logImage);
            }
        }
        return matrixImage;
    }

    /**
     * 将log图片画入二维码中
     */
    private static BufferedImage drawNewImage(BufferedImage matrixImage, BufferedImage logImage) {
        // 画出中间含有log的二维码图形对象,x 是log图像显示的位置，y是log图像
        int x = (matrixImage.getWidth() - logImage.getWidth()) / 2;
        int y = (matrixImage.getHeight() - logImage.getHeight()) / 2;
        // 使用二维码图形创建图形工具
        Graphics2D erCodeUtil = matrixImage.createGraphics();
        erCodeUtil.drawImage(logImage, x, y, null);
        erCodeUtil.dispose();
        logImage.flush();
        return matrixImage;
    }

    /**
     * 将矩阵图形化
     */
    private static BufferedImage toBufferredImage(BitMatrix bitMatrix) {
        int width = bitMatrix.getWidth();
        int height = bitMatrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                image.setRGB(i, j, bitMatrix.get(i, j) ? 0XFF000000 : 0XFFFFFF);
            }
        }
        return image;
    }
}
